package com.property.demo.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.Sort;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 排序工具类，用于处理Spring Data排序功能
 */
public class SortUtil {
    
    private static final Logger logger = LoggerFactory.getLogger(SortUtil.class);
    
    // 允许排序的属性列表
    private static final List<String> VALID_PROPERTIES = Arrays.asList(
        "id", "createdAt", "updatedAt", "fee", "startDate", "endDate", 
        "usageType", "paymentStatus"
    );
    
    /**
     * 从字符串解析单个排序规则
     * @param sortString 格式为"property,direction"的字符串
     * @return 排序规则
     */
    public static Sort parseSort(String sortString) {
        logger.info("解析排序参数: {}", sortString);
        
        if (sortString == null || sortString.trim().isEmpty()) {
            logger.info("使用默认排序: id DESC");
            return Sort.by(Sort.Direction.DESC, "id");
        }
        
        String[] parts = sortString.split(",");
        String property = parts[0].trim();
        
        // 验证属性是否有效
        if (!isValidProperty(property)) {
            logger.warn("排序属性 '{}' 无效，将使用默认排序", property);
            return Sort.by(Sort.Direction.DESC, "id");
        }
        
        Sort.Direction direction = Sort.Direction.ASC;
        if (parts.length > 1) {
            try {
                direction = Sort.Direction.fromString(parts[1].trim());
            } catch (IllegalArgumentException e) {
                logger.warn("排序方向 '{}' 无效，默认使用升序", parts[1]);
            }
        }
        
        logger.debug("创建排序规则: {} {}", property, direction);
        return Sort.by(direction, property);
    }
    
    /**
     * 从字符串数组中获取排序规则
     * @param sort 格式为["property,direction", ...]的字符串数组
     * @return 排序规则列表
     */
    public static List<Sort.Order> getOrders(String[] sort) {
        List<Sort.Order> orders = new ArrayList<>();
        
        if (sort != null) {
            logger.info("处理排序参数: {}", Arrays.toString(sort));
            
            for (String sortOrder : sort) {
                String[] parts = sortOrder.split(",");
                if (parts.length > 0) {
                    String property = parts[0];
                    
                    // 验证属性是否有效
                    if (!isValidProperty(property)) {
                        logger.warn("排序属性 '{}' 无效，将使用默认排序", property);
                        continue;
                    }
                    
                    Sort.Direction direction = Sort.Direction.ASC;
                    
                    if (parts.length > 1) {
                        try {
                            direction = Sort.Direction.fromString(parts[1]);
                        } catch (IllegalArgumentException e) {
                            logger.warn("排序方向 '{}' 无效，默认使用升序", parts[1]);
                            direction = Sort.Direction.ASC;
                        }
                    }
                    
                    logger.debug("添加排序规则: {} {}", property, direction);
                    orders.add(new Sort.Order(direction, property));
                }
            }
        }
        
        // 如果没有有效的排序规则，使用默认排序
        if (orders.isEmpty()) {
            logger.info("使用默认排序: id DESC");
            orders.add(new Sort.Order(Sort.Direction.DESC, "id"));
        }
        
        return orders;
    }
    
    /**
     * 检查属性是否有效
     * @param property 要检查的属性名
     * @return 如果属性有效则返回true
     */
    private static boolean isValidProperty(String property) {
        // 检查预定义的有效属性列表
        if (VALID_PROPERTIES.contains(property)) {
            return true;
        }
        
        // 尝试在实体类中查找属性
        try {
            Class<?> entityClass = Class.forName("com.property.demo.model.ParkingUsage");
            for (Field field : entityClass.getDeclaredFields()) {
                if (field.getName().equals(property)) {
                    return true;
                }
            }
        } catch (ClassNotFoundException e) {
            logger.error("找不到实体类", e);
        }
        
        return false;
    }
} 